package com.cn.gmall.product.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.cn.gmall.model.product.BaseCategoryTrademark;
import com.cn.gmall.model.product.BaseTrademark;
import com.cn.gmall.model.product.CategoryTrademarkVo;
import com.cn.gmall.product.mapper.BaseCategoryTrademarkMapper;
import com.cn.gmall.product.mapper.BaseTrademarkMapper;
import com.cn.gmall.product.service.BaseCategoryTrademarkService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class BaseCategoryTrademarkServiceImpl extends ServiceImpl<BaseCategoryTrademarkMapper,BaseCategoryTrademark>  implements BaseCategoryTrademarkService {

    @Autowired
    BaseTrademarkMapper baseTrademarkMapper;

    @Autowired
    BaseCategoryTrademarkMapper baseCategoryTrademarkMapper;



    /**
     * 保存所选中搞的品牌
     * @param categoryTrademarkVo
     */
    @Override
    public void saveCategoryTrademark(CategoryTrademarkVo categoryTrademarkVo) {
        List<Long> trademarkIdList = categoryTrademarkVo.getTrademarkIdList();

        if (CollectionUtils.isEmpty(trademarkIdList)) {
            return;
        }


/* //        将trademarkIdList 的id数组转换 一个 baseCategoryTrademark的数组

        List<BaseCategoryTrademark> bcList = trademarkIdList.stream().map(tre -> {
            BaseCategoryTrademark baseCategoryTrademark = new BaseCategoryTrademark();
            baseCategoryTrademark.setTrademarkId(tre);
            baseCategoryTrademark.setCategory3Id(categoryTrademarkVo.getCategory3Id());
            return baseCategoryTrademark;
        }).collect(Collectors.toList());
//将trademarkIdList 中的对象插入到表
     bcList.stream().forEach(baseCategoryTrademark -> {
         baseCategoryTrademarkMapper.insert(baseCategoryTrademark);
     });
     */
        /**
         * 直接遍历 id集合封装对象 插入数据
         */
        trademarkIdList.stream().forEach(treId->{
            BaseCategoryTrademark baseCategoryTrademark = new BaseCategoryTrademark();
            baseCategoryTrademark.setCategory3Id(categoryTrademarkVo.getCategory3Id());
            baseCategoryTrademark.setTrademarkId(treId);
            baseCategoryTrademarkMapper.insert(baseCategoryTrademark);
        });
    }

    /**
     * 根据category3Id获取可选品牌列表
     * @param category3Id
     * @return
     */
    @Override
    public List<BaseTrademark> findCurrentTrademarkList(Long category3Id) {
//
        LambdaQueryWrapper<BaseCategoryTrademark> bcQueryWrapper = new LambdaQueryWrapper<>();
        bcQueryWrapper.eq(BaseCategoryTrademark::getCategory3Id,category3Id);
        bcQueryWrapper.orderByAsc(BaseCategoryTrademark::getTrademarkId);
        List<BaseCategoryTrademark> trademarkList = baseCategoryTrademarkMapper.selectList(bcQueryWrapper);
// 若trademarkIdList 为空 则表示 没有category3Id=category3Id 的 数据 显示所有的数据(即所有的品牌都是可选项)
        if (CollectionUtils.isEmpty(trademarkList)) {
            return  baseTrademarkMapper.selectList(null);
        }
//        若不为空 找到所有相关数据的tradeIdList集合
        List<Long> tradeIdList = trademarkList.stream().map(baseCategoryTrademark -> {
            return baseCategoryTrademark.getTrademarkId();
        }).collect(Collectors.toList());

//        所有的品牌中中 除去tradeIdList集合里面 已经存在的品牌 其它品牌 均为 可选项

        List<BaseTrademark> allList = baseTrademarkMapper.selectList(null); //全部品牌
// 将剩余部分返回
        List<BaseTrademark> resultList = allList.stream().filter(baseTrademark -> {
//            返回 不包含的部分
            return !tradeIdList.contains(baseTrademark.getId());
        }).collect(Collectors.toList());

        return resultList;
    }

    /**
     *根据category3Id获取品牌列表
     * @param category3Id
     * @return
     */

    @Override
    @Transactional
    public List<BaseTrademark> findTrademarkList(Long category3Id) {

//        根据 category3Id=? 查询 trademarkId 集合
        LambdaQueryWrapper<BaseCategoryTrademark> bcQueryWrapper = new LambdaQueryWrapper<>();
        bcQueryWrapper.eq(BaseCategoryTrademark::getCategory3Id,category3Id);
        bcQueryWrapper.orderByAsc(BaseCategoryTrademark::getTrademarkId);
        List<BaseCategoryTrademark> trademarkIdList = baseCategoryTrademarkMapper.selectList(bcQueryWrapper);
//     没找到数据
        if (CollectionUtils.isEmpty(trademarkIdList)) {
            return null;
        }
        ArrayList<BaseTrademark> list = new ArrayList<>();
//        根据 满足条件的trademarkId集合 遍历查询 BaseTrademark集合
        trademarkIdList.stream().forEach(baseCategoryTrademark -> {
            list.add(baseTrademarkMapper.selectById(baseCategoryTrademark.getTrademarkId()));
        });

        return list;
    }
}
